'use strict';
// const axios = require('axios');
const Service = require('egg').Service;
class UserService extends Service {

  /**
   *查询用户
   * @param {*} param0 查询参数
   * @return object or null
   * quickUser *2
   */
  async is_user({ ...args }) {
    const { app } = this;
    const where = { ...args };
    return await app.model.User.findOne({ where, raw: true });
  }

  // 验证码快捷登录 or 创建用户
  async quickUser(payload) {
    const { app, ctx } = this;
    const msg = {};
    const { account, code } = payload;
    const user = { nickname: account, user_name: account };
    const is_user = {};
    const create_user = {};

    // 判断有没有验证码 true =>验证大于5分钟吗 ？ true => 报错
    const verifyCode = await ctx.service.web.verifyCode.showVerifyCode({ account, code });
    // 如果有验证码
    if (verifyCode) {
      // 判断当前时间大于 300000 5分钟吗
      if ((Date.now() - +new Date(verifyCode.updatedAt)) > 300000) {
        msg.msg = '验证码已过期,请重新获取验证码';
        return msg;
      }
    } else { // 没查询到验证码
      msg.msg = '验证码错误,请重新获取验证码';
      return msg;
    }

    // 如果是手机的话
    if (ctx.helper.validMobile(account)) {
      user.mobile = account;
      is_user.type = 'mobile';
      create_user.type = 'mobile';
      is_user.user = await this.is_user({ mobile: account });
      // 判断账户是否已被注册 ？ true去登录 : false去注册
    }
    // 如果是邮箱登录的话
    if (ctx.helper.validEmail(account)) {
      user.email = account;
      is_user.type = 'email';
      create_user.type = 'email';
      is_user.user = await this.is_user({ email: account });
    }
    // 没有找到用户的话
    if (!is_user.user) {
      msg.msg = '该用户已被删除';
      return msg;
    }
    // 查询到用户的话 去登录
    if (is_user.user) {
      if (is_user.user.status === 0 || is_user.user.status === false) {
        msg.msg = '您已被管理员拉入黑名单!  如有疑问请联系管理员';
        msg.code = 401;
        console.log(msg);
        return msg;
      }
      return { status: 'login', data: is_user };
    }
    // 没查询到就去注册
    return createUser();
    /**
     * 创建用户 并分配角色
     * @return Promise
     */
    async function createUser() {
      const transaction = await app.model.transaction();
      try {
        const res_user = await app.model.User.create(user, { transaction });
        create_user.user = res_user.dataValues;
        const defaultRole = await app.model.Role.findOne({ where: { is_default: 1 } });
        // 分配默认角色
        await app.model.UserRole.create(
          {
            user_id: create_user.user.id,
            role_id: defaultRole.id,
          },
          { transaction }
        );
        await transaction.commit();
        return { status: 'register', data: create_user };
      } catch (error) {
        await transaction.rollback();
        console.error('error', error);
      }

    }
  }

  /**
   * 账号密码登录
   * @param {*} payload
   * @return
   */
  async accountAndPasswordToLogin(payload) {
    const { ctx } = this;
    const msg = {};
    const { account, password } = payload;
    const user = {};

    // 如果是手机的话
    if (ctx.helper.validMobile(account)) {
      payload.mobile = account;
      user.loginType = 'mobile';
      user.user = await this.is_user({ mobile: account });
    }
    // 如果是邮箱登录的话
    if (ctx.helper.validEmail(account)) {
      payload.email = account;
      user.loginType = 'email';
      // 1,判断用户是否存在 不存在 报错
      user.user = await this.is_user({ email: account });
    }

    if (!user.user) {
      msg.msg = '账号或密码错误';
      return msg;
    }
    // 2判断该用户是否被管理员拉黑
    if (user.user.status === 0 || user.user.status === false) {
      msg.msg = '您已被管理员拉入黑名单!  如有疑问请联系管理员';
      msg.code = 401;
      console.log(msg);
      return msg;
    }
    // 3，解密后密码是否匹配 不匹配  报错
    const checked = await ctx.compare(password, user.user.password);
    if (!checked) {
      msg.msg = '账号或密码错误 密码不正确';
      return msg;
    }
    return user;
  }

  /**
   * 验证码快捷修改密码
   * @param {*} payload
   * @return
   */
  async quickUpdatePassword(payload) {
    const { ctx, app } = this;
    const msg = {};
    const { account, password, code } = payload;
    const user = {};

    // 如果是手机的话
    if (ctx.helper.validMobile(account)) {
      payload.mobile = account;
      user.user = await this.is_user({ mobile: account });
    }
    // 如果是邮箱的话
    if (ctx.helper.validEmail(account)) {
      payload.email = account;
      user.user = await this.is_user({ email: account });
    }
    // 数据库中没有要找回密码的账号
    if (!user.user) {
      msg.msg = '该账号已被外星人劫走了，请重新注册账号或联系管理员';
      return msg;
    }
    // 判断该用户是否被管理员拉黑
    if (user.user.status === 0 || user.user.status === false) {
      msg.msg = '您已被管理员拉入黑名单!  如有疑问请联系管理员';
      msg.code = 401;
      return msg;
    }
    // 判断有没有验证码 true =>验证大于5分钟吗 ？ true => 报错
    const verifyCode = await ctx.service.web.verifyCode.showVerifyCode({ account, code });
    // 如果有验证码
    if (verifyCode) {
      // 判断当前时间大于 300000 5分钟吗
      if ((Date.now() - +new Date(verifyCode.updatedAt)) > 300000) {
        msg.msg = '验证码已过期,请重新获取验证码';
        return msg;
      }
    } else { // 没查询到验证码
      msg.msg = '验证码错误,请重新获取验证码';
      return msg;
    }
    // 加密用户设置的密码再存入数据库
    const hashPassword = await ctx.genHash(password);
    return await app.model.User.update({ password: hashPassword }, { where: { id: user.user.id } });

  }

  // 修改用户信息
  async updatedUser(id, user) {
    delete user.user_name;// 不允许修改用户名
    const { app } = this;
    return await app.model.User.update(user, { where: { id } });
  }

  // gitHubLogin // 暂时未做存储账号信息
  // async gitHubLogin(code) {
  //   const { app } = this;
  //   const msg = {};
  //   const { client_id, client_secret, access_token_url, user_info_url, redirect_uri } = app.config.github;
  //   if (code && code.length === 20) {
  //     // 向github发送post请求，成功的话会，res里面有一个access_token
  //     const res = await axios({
  //       method: 'post',
  //       url: `${access_token_url}?redirect_uri=${redirect_uri}&client_id=${client_id}&client_secret=${client_secret}&code=${code}`,
  //       headers: { accept: 'application/json' },
  //     });
  //     if (!res.data.access_token) {
  //       msg.msg = '向github发送post请求获取res.data.access_token失败！';
  //       return msg;
  //     }
  //     // 拿到res.data.access_token，再向github发送get请求用户信息
  //     const userinfo = await axios({
  //       method: 'get',
  //       url: `${user_info_url}?access_token=${res.data.access_token}`,
  //       headers: {
  //         accept: 'application/json',
  //         // 这是个坑，一定要这么写，要不然请求不到
  //         Authorization: `token ${res.data.access_token}`,
  //         'Keep-Alive': 'timeout=5',
  //       },
  //     });
  //     if (!userinfo) {
  //       msg.msg = '向github发送get请求用户信息失败！';
  //       return msg;
  //     }

  //     // const { id, avatar_url, name, email } = userinfo.data;
  //     // const result = { id, avatar_url, name, email };
  //     // return result;
  //     return userinfo.data;
  //   }
  // }

  // // WeChatLogin // 暂时未做存储账号信息
  // async WeChatLogin(code) {
  //   const { app, ctx } = this;
  //   const msg = {};
  //   const { AppID, AppSecret, user_info_url, openid } = app.config.wechat;

  //   // 第一步：前端请求CODE
  //   console.log(code);

  //   // 第二步：通过code获取access_token
  //   const access_token = await axios({
  //     method: 'get',
  //     url: `https://api.weixin.qq.com/sns/oauth2/access_token?appid=${AppID}&secret=${AppSecret}&code=${code}&grant_type=authorization_code`,
  //     // headers: { accept: 'application/json' },
  //   });
  //   console.log('获取到access_token', access_token.data);

  //   // 错误返回
  //   if (access_token.data.errcode) {
  //     msg.msg = access_token.errmsg;
  //     return msg;
  //   }

  //   // 第三步：通过access_token调用接口
  //   const userinfo = await axios({
  //     method: 'get',
  //     url: `${user_info_url}?access_token=${access_token.data.access_token}&openid=${openid}&lang=zh_CN`,
  //   });
  //   console.log('获取到userinfo', userinfo.data);

  //   // 错误返回
  //   if (userinfo.data.errcode) {
  //     msg.msg = userinfo.errmsg;
  //     return msg;
  //   }
  //   return userinfo.data;
  // }

  // 获取用户主页个人信息
  async getUserHomePage(user_id) {
    const { app } = this;
		// 用户信息
    const userInfo = await app.model.User.findByPk(user_id);
		delete userInfo.dataValues.password;
		delete userInfo.dataValues.paypassword;
		// 我的关注
		const myFocus = await app.model.Follower.count({ where: { foller_id:user_id } });
		// 我的粉丝
		const myFans = await app.model.Follower.count({ where: { follerd_id:user_id } });
		// 获赞 暂时不开发
		// const praise = {}
		// const comment = await app.model.ArticleComment.count({ where: { follerd_id:user_id } });
		
		return {myFocus,myFans,...userInfo.dataValues}
  }

  // 关注用户
  async addFocus(payload) {
    const { app, ctx } = this;
    const { follerd_id } = payload; // 被关注的用户id
    const foller_id = ctx.state.user.id; // 关注者的id 就是当前登录的id
    const transaction = await app.model.transaction();
    const err = {};
    if (follerd_id === foller_id) {
      err.msg = '不能关注自己';
      return err;
    }
    const isData = await app.model.Follower.findOne({ where: { foller_id, follerd_id } });
    if (isData) {
      err.msg = '您已关注过啦';
      return err;
    }
    const res = await app.model.Follower.create({ foller_id, follerd_id }, transaction);
    if (res.dataValues) {
      await transaction.commit();
      return res.dataValues;
    }
    await transaction.rollback();
    return false;
  }

  // 取消关注用户
  async destroyFocus(follerd_id) {
    const { app, ctx } = this;
    const foller_id = ctx.state.user.id;
    const transaction = await app.model.transaction();
    const res = await app.model.Follower.destroy({ where: { foller_id, follerd_id }, force: true, transaction });
    if (res === 1) {
      await transaction.commit();
      return true;
    }
    await transaction.rollback();
    return false;
  }

  // 根据id判断是否已关注
  async getFocusById(follerd_id) {
    const { app, ctx } = this;
    const foller_id = ctx.state.user.id;
    const isData = await app.model.Follower.findOne({ where: { foller_id, follerd_id } });
    return isData;
  }

  // // 获取用户的关注列表 and 获取用户的粉丝列表 根据用户id
  // async getFriendList(payload) {
  //   const { app } = this;
  //   const Op = app.Sequelize.Op;
  //   const { pageNum = 1, pageSize = 10, follerd_id, foller_id, status, begin_pubdate, end_pubdate } = payload;
  //   const where = {};
  //   if (follerd_id) { where.follerd_id = follerd_id; }// 被关注的用户id
  //   if (foller_id) { where.foller_id = foller_id; }// 关注别人的用户id
  //   if (status) { where.status = status; }// 根据点赞状态查询
  //   if (begin_pubdate && end_pubdate) { // 根据时间查询
  //     where.createdAt = { [Op.between]: [ begin_pubdate, end_pubdate ] };
  //   }// 查询这个字段-xx之间  }
  //   try {
  //     const offset = (pageNum - 1) * pageSize;
  //     const { count, rows } = await app.model.Follower.findAndCountAll({
  //       where,
  //       order: [
  //         [ 'createdAt', 'desc' ],
  //       ],
  //       include: [
  //         {
  //           model: this.app.model.User,
  //           attributes: [ 'nickname', 'avatar', 'id' ], // 只显示哪些字段
  //           as: 'fans',
  //         },
  //         {
  //           model: this.app.model.User,
  //           attributes: [ 'nickname', 'avatar', 'id' ], // 只显示哪些字段
  //           as: 'focus',
  //         },
  //       ],
  //       // raw: true,
  //       offset,
  //       limit: pageSize * 1,

  //     });
  //     return {
  //       pageNum,
  //       pageSize,
  //       total: count,
  //       list: rows,
  //     };
  //   } catch (error) {
  //     console.error(error);
  //     return null;
  //   }
  // }


}

module.exports = UserService;
